6. Processing The Processes

du@DVM:~/Desktop$ readelf -h hello.o
ELF Header:
  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 
  Class:                             ELF64
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              REL (Relocatable file)
  Machine:                           Advanced Micro Devices X86-64
  Version:                           0x1
  Entry point address:               0x0
  Start of program headers:          0 (bytes into file)
  Start of section headers:          600 (bytes into file)
  Flags:                             0x0
  Size of this header:               64 (bytes)
  Size of program headers:           0 (bytes)
  Number of program headers:         0
  Size of section headers:           64 (bytes)
  Number of section headers:         14
  Section header string table index: 13

typedef struct {
    uint32_t sh_name;      // 节名称的索引
    uint32_t sh_type;      // 节的类型
    uint64_t sh_flags;     // 节的标志(在虚拟空间中的访问属性)
    uint64_t sh_addr;      // 节的虚拟内存地址(链接视图无意义)
    uint64_t sh_offset;    // 节在文件中的偏移
    uint64_t sh_size;      // 节的大小
    uint32_t sh_link;      // 节的链接信息
    uint32_t sh_info;      // 链接信息
    uint64_t sh_addralign; // 对齐要求信息
    uint64_t sh_entsize;   // 节中条目的大小
} Elf64_Shdr;

du@DVM:~/Desktop$ readelf -S hello.o
There are 14 section headers, starting at offset 0x258:
Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
       
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .text             PROGBITS         0000000000000000  00000040
       000000000000001e  0000000000000000  AX       0     0     1
  [ 2] .rela.text        RELA             0000000000000000  00000198
       0000000000000030  0000000000000018   I      11     1     8
  [ 3] .data             PROGBITS         0000000000000000  0000005e
       0000000000000000  0000000000000000  WA       0     0     1
  [ 4] .bss              NOBITS           0000000000000000  0000005e
       0000000000000000  0000000000000000  WA       0     0     1
  [ 5] .rodata           PROGBITS         0000000000000000  0000005e
       000000000000000d  0000000000000000   A       0     0     1
  [ 6] .comment          PROGBITS         0000000000000000  0000006b
       000000000000002c  0000000000000001  MS       0     0     1
  [ 7] .note.GNU-stack   PROGBITS         0000000000000000  00000097
       0000000000000000  0000000000000000           0     0     1
  [ 8] .note.gnu.pr[...] NOTE             0000000000000000  00000098
       0000000000000020  0000000000000000   A       0     0     8
  [ 9] .eh_frame         PROGBITS         0000000000000000  000000b8
       0000000000000038  0000000000000000   A       0     0     8
  [10] .rela.eh_frame    RELA             0000000000000000  000001c8
       0000000000000018  0000000000000018   I      11     9     8
  [11] .symtab           SYMTAB           0000000000000000  000000f0
       0000000000000090  0000000000000018          12     4     8
  [12] .strtab           STRTAB           0000000000000000  00000180
       0000000000000013  0000000000000000           0     0     1
  [13] .shstrtab         STRTAB           0000000000000000  000001e0
       0000000000000074  0000000000000000           0     0     1
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
  L (link order), O (extra OS processing required), G (group), T (TLS),
  C (compressed), x (unknown), o (OS specific), E (exclude),
  D (mbind), l (large), p (processor specific)

+-------------------------+-------------------------+   0x000
| ELF Header              | 64 bytes (0x40)         |
+-------------------------+-------------------------+   0x040
| .text                   | 30 bytes (0x1e)         |
+-------------------------+-------------------------+   0x05e
| .data                   | 0 bytes                 |
+-------------------------+-------------------------+   0x05e
| .bss                    | 0 bytes                 |
+-------------------------+-------------------------+   0x05e
| .rodata                 | 13 bytes (0x0d)         |
+-------------------------+-------------------------+   0x06b
| .comment                | 44 bytes (0x2c)         |
+-------------------------+-------------------------+   0x097
| .note.GNU-stack         | 0 bytes                 |
+-------------------------+-------------------------+   0x097
+-------------------------+-------------------------+   0x098(0x97对齐)
| .note.gnu.property      | 32 bytes (0x20)         |
+-------------------------+-------------------------+   0x0b8
| .eh_frame               | 56 bytes (0x38)         |
+-------------------------+-------------------------+   0x0f0
| .symtab                 | 144 bytes (0x90)        |
+-------------------------+-------------------------+   0x180
| .strtab                 | 19 bytes (0x13)         |
+-------------------------+-------------------------+   0x193
+-------------------------+-------------------------+   0x198(0x193对齐)
| .rela.text              | 48 bytes (0x30)         |
+-------------------------+-------------------------+   0x1c8
| .rela.eh_frame          | 24 bytes (0x18)         |
+-------------------------+-------------------------+   0x1e0
| .shstrtab               | 116 bytes (0x74)        |
+-------------------------+-------------------------+   0x254(596 Bytes)
+-------------------------+-------------------------+   0x258(600 Bytes)
| Section Headers         | 896 bytes (14 * 64)     |
+-------------------------+-------------------------+   0x5d8(600+896 Bytes)

du@DVM:~/Desktop$ hexdump -C hello.o
00000000  7f 45 4c 46 02 01 01 00  00 00 00 00 00 00 00 00  |.ELF............|
...
00000050  89 c7 e8 00 00 00 00 b8  00 00 00 00 5d c3 68 65  |............].he|
00000060  6c 6c 6f 2c 20 77 6f 72  6c 64 00 00 47 43 43 3a  |llo, world..GCC:|
...
000005d0  00 00 00 00 00 00 00 00                           |........|
000005d8

du@DVM:~/Desktop$ readelf -h hello
ELF Header:
  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 
  Class:                             ELF64
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              DYN (Position-Independent Executable file)
  Machine:                           Advanced Micro Devices X86-64
  Version:                           0x1
  Entry point address:               0x1060
  Start of program headers:          64 (bytes into file)
  Start of section headers:          13976 (bytes into file)
  Flags:                             0x0
  Size of this header:               64 (bytes)
  Size of program headers:           56 (bytes)
  Number of program headers:         13
  Size of section headers:           64 (bytes)
  Number of section headers:         31
  Section header string table index: 30

typedef struct {
    uint32_t p_type;   // 段的类型
    uint32_t p_flags;  // 段的权限标志
    uint64_t p_offset; // 段在文件中的偏移量
    uint64_t p_vaddr;  // 段在内存中的虚拟地址
    uint64_t p_paddr;  // 段在内存中的物理地址
    uint64_t p_filesz; // 段在文件中的大小
    uint64_t p_memsz;  // 段在内存中的大小
    uint64_t p_align;  // 段在内存中的对齐要求
} Elf64_Phdr;

du@DVM:~/Desktop$ readelf -l hello

Elf file type is DYN (Position-Independent Executable file)
Entry point 0x1060
There are 13 program headers, starting at offset 64

Program Headers:
  Type           Offset             VirtAddr           PhysAddr
                 FileSiz            MemSiz              Flags  Align
  PHDR           0x0000000000000040 0x0000000000000040 0x0000000000000040
                 0x00000000000002d8 0x00000000000002d8  R      0x8
  INTERP         0x0000000000000318 0x0000000000000318 0x0000000000000318
                 0x000000000000001c 0x000000000000001c  R      0x1
      [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]
  LOAD           0x0000000000000000 0x0000000000000000 0x0000000000000000
                 0x0000000000000628 0x0000000000000628  R      0x1000
  LOAD           0x0000000000001000 0x0000000000001000 0x0000000000001000
                 0x0000000000000175 0x0000000000000175  R E    0x1000
  LOAD           0x0000000000002000 0x0000000000002000 0x0000000000002000
                 0x00000000000000f4 0x00000000000000f4  R      0x1000
  LOAD           0x0000000000002db8 0x0000000000003db8 0x0000000000003db8
                 0x0000000000000258 0x0000000000000260  RW     0x1000
  DYNAMIC        0x0000000000002dc8 0x0000000000003dc8 0x0000000000003dc8
                 0x00000000000001f0 0x00000000000001f0  RW     0x8
  NOTE           0x0000000000000338 0x0000000000000338 0x0000000000000338
                 0x0000000000000030 0x0000000000000030  R      0x8
  NOTE           0x0000000000000368 0x0000000000000368 0x0000000000000368
                 0x0000000000000044 0x0000000000000044  R      0x4
  GNU_PROPERTY   0x0000000000000338 0x0000000000000338 0x0000000000000338
                 0x0000000000000030 0x0000000000000030  R      0x8
  GNU_EH_FRAME   0x0000000000002014 0x0000000000002014 0x0000000000002014
                 0x0000000000000034 0x0000000000000034  R      0x4
  GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
                 0x0000000000000000 0x0000000000000000  RW     0x10
  GNU_RELRO      0x0000000000002db8 0x0000000000003db8 0x0000000000003db8
                 0x0000000000000248 0x0000000000000248  R      0x1

 Section to Segment mapping:
  Segment Sections...
   00     
   01     .interp 
   02     .interp .note.gnu.property .note.gnu.build-id .note.ABI-tag .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt 
   03     .init .plt .plt.got .plt.sec .text .fini 
   04     .rodata .eh_frame_hdr .eh_frame 
   05     .init_array .fini_array .dynamic .got .data .bss 
   06     .dynamic 
   07     .note.gnu.property 
   08     .note.gnu.build-id .note.ABI-tag 
   09     .note.gnu.property 
   10     .eh_frame_hdr 
   11     
   12     .init_array .fini_array .dynamic .got 

00002000  01 00 02 00 68 65 6c 6c  6f 2c 20 77 6f 72 6c 64  |....hello, world|
00002010  00 00 00 00 01 1b 03 3b  30 00 00 00 05 00 00 00  |.......;0.......|

long state;                     /* state of the process */   
struct sched entity se;         /* scheduling information */ 
struct task struct *parent;     /* this process’s parent */ 
struct list head children;      /* this process’s children */ 
struct files struct *files;     /* list of open files */ 
struct mm struct *mm;           /* address space */

Start               End                  Size    Use
0x0000000000000000  0x0000ffffffffffff   256TB   user
0xffff000000000000  0xffffffffffffffff   256TB   kernel

#include <stdlib.h>
int global_b; //Uninitialized global variable
int main(){
	static int static_c = 10;//static variable initializing
	char* local_d = "hi,world";
	void* p = malloc(100);
	static_c ++;
	free(p);
	return 0;
}

Mapped address spaces:
Start Addr           End Addr       Size     Offset   Perms  objfile
0x555555554000     0x555555555000   0x1000    0x0     r--p   hiprocess
0x555555555000     0x555555556000   0x1000    0x1000  r-xp   hiprocess .text
0x555555556000     0x555555557000   0x1000    0x2000  r--p   hiprocess .rodata
0x555555557000     0x555555558000   0x1000    0x2000  r--p   hiprocess .rodata
0x555555558000     0x555555559000   0x1000    0x3000  rw-p   hiprocess .data & bss
0x555555559000     0x55555557a000   0x21000     0x0   rw-p   [heap]
0x7ffff7c00000     0x7ffff7c28000   0x28000     0x0   r--p   libc.so.6
0x7ffff7c28000     0x7ffff7dbd000   0x195000 0x28000  r-xp   libc.so.6
0x7ffff7dbd000     0x7ffff7e15000   0x58000  0x1bd000 r--p   libc.so.6
0x7ffff7e15000     0x7ffff7e16000    0x1000  0x215000 ---p   libc.so.6
0x7ffff7e16000     0x7ffff7e1a000    0x4000  0x215000 r--p   libc.so.6
0x7ffff7e1a000     0x7ffff7e1c000    0x2000  0x219000 rw-p   libc.so.6
0x7ffff7e1c000     0x7ffff7e29000    0xd000      0x0  rw-p   
0x7ffff7fa9000     0x7ffff7fac000    0x3000      0x0  rw-p   
0x7ffff7fbb000     0x7ffff7fbd000    0x2000      0x0  rw-p   
0x7ffff7fbd000     0x7ffff7fc1000    0x4000      0x0  r--p   [vvar]
0x7ffff7fc1000     0x7ffff7fc3000    0x2000      0x0  r-xp   [vdso]
0x7ffff7fc3000     0x7ffff7fc5000    0x2000      0x0  r--p   ld-linux-x86-64.so.2
0x7ffff7fc5000     0x7ffff7fef000    0x2a000  0x2000  r-xp   ld-linux-x86-64.so.2
0x7ffff7fef000     0x7ffff7ffa000    0xb000   0x2c000 r--p   ld-linux-x86-64.so.2
0x7ffff7ffb000     0x7ffff7ffd000    0x2000   0x37000 r--p   ld-linux-x86-64.so.2
0x7ffff7ffd000     0x7ffff7fff000    0x2000   0x39000 rw-p   ld-linux-x86-64.so.2
0x7ffffffde000     0x7ffffffff000    0x21000     0x0  rw-p   [stack]
0xffffffffff600000 0xffffffffff601000 0x1000     0x0  --xp   [vsyscall]

(gdb) print &static_c
$1 = (int *) 0x555555558010 <static_c>
(gdb) print &local_d
$2 = (char **) 0x7fffffffdee0
(gdb) print &global_b
$3 = (int *) 0x555555558018 <global_b>
(gdb) print &p
$4 = (void **) 0x7fffffffdee8
(gdb) print p
$5 = (void *) 0x5555555592a0
(gdb) print local_d
$6 = 0x555555556004 "hi,world"

#include <unistd.h>

pid_t fork();
/* 
Parameters: None.

Return value: 
	- On success: Returns the process ID (PID) of the child process to the parent process, and 0 to the child process.
	- On failure: Returns -1 and sets errno appropriately.
*/

#include <unistd.h>

int execl(const char *path, const char *arg, ...);
/* 
Parameters:
	1. path: The path to the executable file.
	2. arg: The argument list, terminated by a NULL pointer.

Return value:
	- On success: Does not return, as the new program replaces the current process.
	- On failure: Returns -1 and sets errno appropriately.
*/

int execv(const char *path, char *const argv[]);
/* 
Parameters:
	1. path: The path to the executable file.
	2. argv: An array of argument strings, terminated by a NULL pointer.

Return value:
	- On success: Does not return, as the new program replaces the current process.
	- On failure: Returns -1 and sets errno appropriately.
*/

#include <stdlib.h>

void exit(int status);
/* 
Parameters:
	1. status: The exit status of the process. Typically, 0 indicates success, and non-zero indicates failure.

Return value: No return.
*/

#include <unistd.h>

void _exit(int status);
/* 
Parameters:
    1. status: The exit status of the process. Typically, 0 indicates success, and non-zero indicates failure.

Return value: No return.
*/

// fork.c

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h> 

int main(){
	int ret = fork();
	if(ret == 0){
		printf("This is child process.\n");
	}
	else{
		printf("This is parent process.\n");
		wait(NULL);
	}
	return 0;
}

// fork.c

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h> 

int main() {
    int ret = fork();
    if (ret == 0) {
        char *args[] = { NULL }; 
        execv("./hello", args);
    } else {
        wait(NULL); 
    }
    return 0;
}

execve("./fork", ["./fork"], 0x7ffeae4313f8 /* 55 vars */) = 0
...
clone(child_stack=NULL, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLDstrace: Process 20909 attached
, child_tidptr=0x72b7e9c79a10) = 20909
...
[pid 20909] execve("./hello", [], 0x7fffaaac2478 /* 55 vars */) = 0
...
[pid 20909] exit_group(0)               = ?
[pid 20909] +++ exited with 0 +++
<... wait4 resumed>NULL, 0, NULL)       = 20909
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=20909, si_uid=1000, si_status=0, si_utime=0, si_stime=0} ---
exit_group(0)                           = ?
+++ exited with 0 +++

// spawn.c

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <spawn.h>
#include <stdlib.h>

extern char **environ;

int main() {
    pid_t pid;
    char *args[] = { "./hello", NULL };

    int status = posix_spawn(&pid, "./hello", NULL, NULL, args, environ);
    if (status == 0) {
        printf("Child process created with PID: %d\n", pid);
        waitpid(pid, NULL, 0); 
    } else {
        perror("posix_spawn failed: ");
    }
    return 0;
}

#include <sched.h>

int clone3(struct clone_args *cl_args, size_t size);
/* 
Parameters:
	1. cl_args: A pointer to a struct clone_args, which contains various fields to specify the behavior and properties of the child process.
	2. size: The size of the struct clone_args structure.

Return value:
	- On success: Returns the process ID (PID) of the child process.
	- On failure: Returns -1 and sets errno appropriately.
*/

struct clone_args {
    uint64_t flags;
    int64_t pidfd;
    uint64_t child_tid;
    uint64_t parent_tid;
    uint64_t exit_signal;
    uint64_t stack;
    uint64_t stack_size;
    uint64_t tls;
    uint64_t set_tid;
    uint64_t set_tid_size;
    uint64_t cgroup;
};
/* struct clone_args fields:
- flags: A bitmask of flags that control the behavior of the child process. Common flags include CLONE_VM, CLONE_FS, CLONE_FILES, CLONE_SIGHAND, CLONE_PARENT, CLONE_THREAD, CLONE_VFORK, CLONE_SYSVSEM, CLONE_SETTLS, CLONE_PARENT_SETTID, and CLONE_CHILD_CLEARTID.
- pidfd: A file descriptor that refers to the PID of the child process.
- child_tid: A pointer to a location where the child process's thread ID will be stored.
- parent_tid: A pointer to a location where the parent process's thread ID will be stored.
- exit_signal: The signal to be sent to the parent when the child exits.
- stack: A pointer to the stack space for the child process.
- stack_size: The size of the stack space.
- tls: A pointer to the thread-local storage (TLS) area.
- set_tid: A pointer to an array of TIDs to be set in the child.
- set_tid_size: The number of TIDs in the set_tid array.
- cgroup: A file descriptor referring to the cgroup to which the child process should be added.
*/

/* Common flags:
- CLONE_VM: The child process shares the same memory space as the parent process.
- CLONE_FS: The child process shares the same file system information as the parent process.
- CLONE_FILES: The child process shares the same file descriptors as the parent process.
- CLONE_SIGHAND: The child process shares the same signal handlers as the parent process.
- CLONE_PARENT: The child process has the same parent process as the calling process.
- CLONE_THREAD: The child process is placed in the same thread group as the calling process.
- CLONE_VFORK: The parent process is suspended until the child process calls execve() or _exit().
- CLONE_SYSVSEM: The child process shares System V semaphore adjustments with the parent process.
- CLONE_SETTLS: The child process uses the TLS (Thread-Local Storage) area specified in the tls field.
- CLONE_PARENT_SETTID: The child's TID is set in the parent_tid field in the parent process.
- CLONE_CHILD_SETTID: The child's TID is set in the child_tid field in the child process.
- CLONE_CHILD_CLEARTID: The child process's TID is cleared in the child_tid field when the child exits.
- CLONE_UNTRACED: The child process is not traced by the parent process.
*/

#define _GNU_SOURCE
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <linux/sched.h>
#include <sys/syscall.h>

struct clone_args {
    uint64_t flags;
    int64_t pidfd;
    uint64_t child_tid;
    uint64_t parent_tid;
    uint64_t exit_signal;
    uint64_t stack;
    uint64_t stack_size;
    uint64_t tls;
    uint64_t set_tid;
    uint64_t set_tid_size;
    uint64_t cgroup;
};

extern char **environ;

int main() {
    pid_t pid;
    char *args[] = { "./hello", NULL };
    struct clone_args cl_args = {
        .flags = CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID,
        .pidfd = 0,
        .child_tid = 0,
        .parent_tid = 0,
        .exit_signal = SIGCHLD,
        .stack = 0,
        .stack_size = 0,
        .tls = 0,
        .set_tid = 0,
        .set_tid_size = 0,
        .cgroup = 0
    };

    pid = syscall(SYS_clone3, &cl_args, sizeof(cl_args));
    if (pid == -1) {
        perror("clone3 failed");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {
        // Child process
        execve("./hello", args, environ);
        perror("execve failed");
        exit(EXIT_FAILURE);
    } else {
        // Parent process
        printf("Child process created with PID: %d\n", pid);
        waitpid(pid, NULL, 0);
    }
    return 0;
}

#include <unistd.h>
#include <sys/types.h>

pid_t getpgid(pid_t pid);
/* 
Parameters:
	1. pid: Process ID of the target process. If pid is 0, getpgid() returns the PGID of the calling process.

Return value:
	- On success, returns the PGID of the specified process.
	- On failure, returns -1 and sets errno to indicate the error.
*/

int setpgid(pid_t pid, pid_t pgid);
/* 
Parameters:
	1. pid: Process ID of the target process. If pid is 0, setpgid() sets the PGID of the calling process.
	2. pgid: Process Group ID to be assigned. If pgid is 0, the PGID is set to the PID of the process specified by pid.

Return value:
	- On success, returns 0.
	- On failure, returns -1 and sets errno to indicate the error.
*/

#include <unistd.h>
#include <sys/types.h>

pid_t getpgrp(void);
/* 
Parameters: None.

Return value:
	- On success, returns the PGID of the calling process.
	- On failure, returns -1 and sets errno to indicate the error.
*/

int setpgrp(void);
/* 
Parameters: None.

Return value:
	- On success, returns 0.
	- On failure, returns -1 and sets errno to indicate the error.
*/

pid_t getsid(pid_t pid);
/* 
Parameters:
	1. pid: Process ID of the target process. If pid is 0, getsid() returns the SID of the calling process.

Return value:
	- On success, returns the SID of the specified process.
	- On failure, returns -1 and sets errno to indicate the error.
*/

pid_t setsid(void);
/* 
Parameters: None.

Return value:
	- On success, returns the SID of the calling process.
	- On failure, returns -1 and sets errno to indicate the error.
*/

pid_t tcgetpgrp(int fd);
/* 
Parameters:
	1. fd: File descriptor of the terminal.

Return value:
	- On success, returns the PGID of the foreground process group associated with the terminal.
	- On failure, returns -1 and sets errno to indicate the error.
*/

int tcsetpgrp(int fd, pid_t pgrp);
/* 
Parameters:
	1. fd: File descriptor of the terminal.
	2. pgrp: Process Group ID to be set as the foreground process group.

Return value:
	- On success, returns 0.
	- On failure, returns -1 and sets errno to indicate the error.
*/

pid_t tcgetsid(int fd);
/* 
Parameters:
	1. fd: File descriptor of the terminal.

Return value:
	- On success, returns the SID of the session leader for the terminal.
	- On failure, returns -1 and sets errno to indicate the error.
*/